package com.cskaoyan.javse.oop3._2inner._4loacl._2usecase;

/**
 * @description: 局部内部类的使用场景
 * @author: wuguidong@cskaoyan.onaliyun.com
 **/

import com.sun.org.apache.regexp.internal.RE;

/**
 * 局部内部类经常使用在以下两个场景中:
 *      1.方法需要返回一个对象时
 *      2.方法需要传入一个对象时
 *
 * 1.方法需要返回一个对象时,可以在方法的局部位置写一个局部内部类继承/实现外部的类/接口,返回作为方法的返回值
 *      原因是方法的返回值类型位置填入一个类名/接口名时,是可以返回它们的子类对象的
 *
 * 2.方法需要传入一个对象实参时,可以在调用方法的位置定义一个局部内部类来继承/实现外部的类/接口,然后创建对象,作为方法调用的实参传入方法
 *      原因是方法的形参位置填入一个类名/接口名时,是可以传入它们的子类对象的
 *
 * 使用局部内部类的优缺点:
 * 优点:
 *      1.绝对对外界隐藏,封装
 *      2.相比较于传统的定义类,然后创建对象,它更加简洁省事(匿名内部类,lambda)
 *
 * 缺点:
 *      一次性的,在方法外部该类不可见
 *
 * 综上,假如在局部位置需要一次性的使用某个对象,可以使用局部内部类,但是如果多次在不同的方法中使用,使用局部内部类就得不偿失了
 *
 */
public class Demo {
    public static void main(String[] args) {
        test().method();
        test2().method();
        //在main方法中定义局部内部类
        class IAImpl implements IA{
            @Override
            public void method() {
                System.out.println("我实现了接口A");
            }
        }
        test(new IAImpl());
    }

    public static void test(IA ia){
        //方法需要一个接口的实现类对象
        ia.method();
    }

    public static Father test() {
        //return new Father();
        //我希望能写一个类继承Father,然后修改里面的方法实现
        class Son extends Father {
            @Override
            void method() {
                System.out.println("son");
            }
        }
        return new Son();
    }

    public static AbstractA test2() {
        class A extends AbstractA {
            @Override
            void method() {
                System.out.println("我实现了抽象类A");
            }
        }
        return new A();
    }
}


interface IA {
    void method();
}

abstract class AbstractA {
    abstract void method();
}


class Father {
    void method() {
        System.out.println("father");
    }
}

class Son extends Father {
    @Override
    void method() {
        System.out.println("son");
    }
}